I love this. This is a great idea. We need this.

Let's think about feature design a little bit!

I know of two WASM package manager thingies:

• https://warg.io
• https://wapm.io

WAPM is real. WARG is a proposal with a reference implementation that's under active development that might become real. If we generalize, we should support both registries. This leads us to a cli invocation like this:

serval pull wapm author/package@version
serval pull wapm ceejbot/loudbot
serval pull warg bytecodealliance.org/[email protected]

Note that I'm going with @version optionally because that's what all the other package manager clis seem to do.

We can pass the registry string into the pull() function in the cli implementation, and then it can be parsed by the specific registry implementation.

I have some specific suggestions about how we handle the specific registry implementations. Right now you're passing a string into a parse() function, which goes on to fill out some struct fields with registry-specific format strings at runtime. I suggest we restructure to make Rust's type system do this work for us.

Here's a possible implementation:

enum PackageRegistry {
    Wapm,
    Warg
}

impl PackageRegistry {
    fn download_url(&self, pkg: &PackageSpec) -> String {
        match self {
            PackageRegistry::Wapm => {
                format!("https://registry-cdn.wapm.io/contents/{}/{}/{}/target/wasm32-wasi/release/{}.wasm", pkg.author, pkg.name, pkg.version, pkg.name)
            },
            PackageRegistry::Warg => todo!(),
        }
    }

    // even cooler....
    fn download(&self, pkg: &PackageSpec) -> Result<Bytes, ServalError> {
        // do the work of downloading from this kind of registry
    }
}

pub struct PackageSpec {
    author: String,
    name: String,
    version: String,
    registry: PackageRegistry,
    // any other useful fields
}

impl PackageSpec {
    // other useful functions here

    pub fn download_url(&self) -> String {
        self.registry.download_url(self)
    }
}

impl TryFrom<&str> for PackageSpec {
    // put your parsing code here
}

The advantage of this approach is that different registries might have different ways to download, e.g., different ways to authenticate. We can hide that inside a specific registry download() implementation if we need to and get rid of the download_url() function. You can probably think of a bunch of different ways to achieve the goal of hiding the registry-specific stuff as much as possible.

The interesting Rust lesson here is to notice that I swapped out your match on a string approach for matching on an enum.

As before, some optional comments aimed at being rusty!

Posting a comment solely to get GitHub to stop showing me this PR under my Review Requests 😂 Hope you're well!